package persistencia;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;

import model.ConTemporada;
import model.Conjunto;
import model.ItemMaterial;
import model.Material;
import model.Prenda;
import model.Producto;
import model.SinTemporada;

public class AdministradorPersistenciaProducto {
	
	private static AdministradorPersistenciaProducto instancia;
	
	public AdministradorPersistenciaProducto(){
		
	}
	
	/* SINGLETON */
	
	public static AdministradorPersistenciaProducto getInstancia(){
		if(instancia == null){
			instancia = new AdministradorPersistenciaProducto();
		}
		return instancia;
	}
	
	/* DEVUELVE UN PRODUCTO */

	public Producto selectProducto(int codigo) {
		
		//Obtener conexion BD 
		Connection con = PoolConnection.getPoolConnection().getConnection();
		
		PreparedStatement ps = null;
		PreparedStatement ps2 = null;
		ResultSet rs = null;
		ResultSet rs2 = null;
		Producto producto = null;

		
		try{
			
			String SQLprenda = "SELECT * from prendas WHERE codigoPrenda ="+codigo;
			
			ps = con.prepareStatement(SQLprenda);
			rs = ps.executeQuery();
			
			
			while(rs.next()){
				
				if(rs.getString("estacion") != "Sin Estacion"){
					
					
					producto = new ConTemporada(rs.getInt("codigoPrenda"), rs.getString("nombre"), rs.getInt("stock"), rs.getString("estacion"));
					PoolConnection.getPoolConnection().realeaseConnection(con);
				}
				
				if(rs.getString("estacion") == "Sin Estacion"){
					
					
					producto = new SinTemporada(rs.getInt("codigoPrenda"), rs.getString("nombre"), rs.getInt("stock"));
					PoolConnection.getPoolConnection().realeaseConnection(con);
				}
				
			}
			
			if(producto == null){
				
				String SQLconjunto = "SELECT * from conjuntos WHERE codigoConjunto ="+codigo;
				
				ps2 = con.prepareStatement(SQLconjunto);
				rs2 = ps2.executeQuery();
				
				while(rs2.next()){
					
					producto = new Conjunto(rs2.getInt("codigoConjunto"), rs2.getString("nombre"), rs2.getFloat("descuento"));
					PoolConnection.getPoolConnection().realeaseConnection(con);
				}
				
			}
			
			
		}
		catch( SQLException e ) 
	      {
				System.out.println("Mensaje Error al Cargar Producto: " + e.getMessage());
				System.out.println("Stack Trace al Cargar Producto: " + e.getStackTrace());
				PoolConnection.getPoolConnection().realeaseConnection(con);
	      }
		return producto;
	}
	
	/* DEVUELVE LOS PRODUCTOS DE UN CONJUNTO */

	public Collection<Producto> selectProductosConjunto(int codigo) {
		
		//Obtener conexion BD 
		Connection con = PoolConnection.getPoolConnection().getConnection();
		
		PreparedStatement ps = null;
		ResultSet rs = null;
		Producto producto = null;
		Collection<Producto> productos = null;
		
		
		try{
			
			String SQL = "SELECT * from conjuntosProductos WHERE codigoConjunto ="+codigo;
			
			ps = con.prepareStatement(SQL);
			rs = ps.executeQuery();
			productos = new ArrayList<Producto>();
			
			while(rs.next()){
				
				producto = selectProducto(rs.getInt("codigoProducto"));
				productos.add(producto);
				
			}
			PoolConnection.getPoolConnection().realeaseConnection(con);
			
		}
		
		catch( SQLException e ) 
	      {
				System.out.println("Mensaje Error al Cargar los Productos: " + e.getMessage());
				System.out.println("Stack Trace al Cargar los Productos: " + e.getStackTrace());
				PoolConnection.getPoolConnection().realeaseConnection(con);
	      }
		return productos;
		
	}
	
	/* DEVUELVE LOS ITEMS MATERIAL DE UN PRODUCTO */
	
	public Collection<ItemMaterial> selectItems(int codigo) {
		
		//Obtener conexion BD 
		Connection con = PoolConnection.getPoolConnection().getConnection();
		
		PreparedStatement ps = null;
		
		ResultSet rs = null;
		ItemMaterial item = null;
		Material material = null;
		Collection<ItemMaterial> items = null;
		
		try{
			
			items = new ArrayList<ItemMaterial>();
			String SQL = "SELECT * from prendasMateriales WHERE codigoPrenda ="+codigo;
			
			ps = con.prepareStatement(SQL);
			rs = ps.executeQuery();
			
			while(rs.next()){
				
				material = AdministradorPersistenciaMaterial.getInstancia().selectMaterial(rs.getInt("codigoMaterial"));
				item = new ItemMaterial (material, rs.getFloat("cantidad"));
				items.add(item);
				
			}
			PoolConnection.getPoolConnection().realeaseConnection(con);
			
		}
		catch( SQLException e ) 
	      {
				System.out.println("Mensaje Error al encontrar Material: " + e.getMessage());
				System.out.println("Stack Trace al encontrar Material: " + e.getStackTrace());
				PoolConnection.getPoolConnection().realeaseConnection(con);
	      }
		return items;
	}

	/* INSERTAR PRODUCTO CON TEMPORADA */
	
	public void insertProductoTemporada(ConTemporada producto) {

		//Obtener conexion BD 
		Connection con = PoolConnection.getPoolConnection().getConnection();
		
		PreparedStatement ps = null;
		
		try{
			
			String SQL = "INSERT into prendas (codigoPrenda, nombre, stock, estacion) VALUES (?,?,?,?)";
			
			ps = con.prepareStatement(SQL);
			ps.setInt(1, producto.getCodigo());
			ps.setString(2, producto.getNombre());
			ps.setFloat(3, producto.getStock());
			ps.setString(4, producto.getEstacion());
			ps.execute();
			
			PoolConnection.getPoolConnection().realeaseConnection(con);
		}
		catch( SQLException e ) 
	      {
				System.out.println("Mensaje Error al insertar Producto: " + e.getMessage());
				System.out.println("Stack Trace al insertar Producto: " + e.getStackTrace());
				PoolConnection.getPoolConnection().realeaseConnection(con);
	      }
		
		
	}
	
	/* INSERTAR PRODUCTO SIN TEMPORADA */
	
	public void insertProductoSinTemporada(SinTemporada producto) {

		//Obtener conexion BD 
		Connection con = PoolConnection.getPoolConnection().getConnection();
		
		PreparedStatement ps = null;
		
		try{
			
			String SQL = "INSERT into prendas (codigoPrenda, nombre, stock, estacion) VALUES (?,?,?,?)";
			
			ps = con.prepareStatement(SQL);
			ps.setInt(1, producto.getCodigo());
			ps.setString(2, producto.getNombre());
			ps.setFloat(3, producto.getStock());
			ps.setString(4, "Sin Temporada");
			ps.execute();
			
			PoolConnection.getPoolConnection().realeaseConnection(con);
		}
		catch( SQLException e ) 
	      {
				System.out.println("Mensaje Error al insertar Producto: " + e.getMessage());
				System.out.println("Stack Trace al insertar Producto: " + e.getStackTrace());
				PoolConnection.getPoolConnection().realeaseConnection(con);
	      }
		
		
	}
	
	/* INSERTA UN ITEM MATERIAL EN LA DB */

	public void insertItemMaterial(int codProducto, int codMaterial, float cantidad) {
		//Obtener conexion BD 
				Connection con = PoolConnection.getPoolConnection().getConnection();
				
				PreparedStatement ps = null;
				
				try{
					String SQL = "INSERT into prendasMateriales (codigoPrenda, codigoMaterial, cantidad) VALUES (?,?,?)";
					
					ps = con.prepareStatement(SQL);
					ps.setInt(1, codProducto);
					ps.setInt(2, codMaterial);
					ps.setFloat(3, cantidad);
					ps.execute();
					
					PoolConnection.getPoolConnection().realeaseConnection(con);
					
					
				}
				catch( SQLException e ) 
			      {
						System.out.println("Mensaje Error al ingresar ItemMaterial: " + e.getMessage());
						System.out.println("Stack Trace al ingresar ItemMaterial: " + e.getStackTrace());
						PoolConnection.getPoolConnection().realeaseConnection(con);
			      }
		
	}
	
	/* INSERTA UN CONJUNTO EN LA BD */

	public void insertConjunto(int codigo, String nombre, float descuento) {
		//Obtener conexion BD 
		Connection con = PoolConnection.getPoolConnection().getConnection();
		
		PreparedStatement ps = null;
		
		try{
			String SQL = "INSERT into conjuntos (codigoConjunto, nombre, descuento) VALUES (?,?,?)";
			
			ps = con.prepareStatement(SQL);
			ps.setInt(1, codigo);
			ps.setString(2, nombre);
			ps.setFloat(3, descuento);
			ps.execute();
			
			PoolConnection.getPoolConnection().realeaseConnection(con);
		}
		catch( SQLException e ) 
	      {
				System.out.println("Mensaje Error al ingresar Conjunto: " + e.getMessage());
				System.out.println("Stack Trace al ingresar Conjunto: " + e.getStackTrace());
				PoolConnection.getPoolConnection().realeaseConnection(con);
	      }
		
		
	}
	
	/* ASOCIA UN PRODUCTO A UN CONJUNTO EN LA BD */

	public void insertProductoAConjunto(int codConjunto, Producto prod) {
		
		//Obtener conexion BD 
				Connection con = PoolConnection.getPoolConnection().getConnection();
				
				PreparedStatement ps = null;
				
				
				try{
					
					String SQL = "INSERT into conjuntosProductos (codigoConjunto, codigoProducto, tipoProducto) VALUES (?,?,?)";
					
					ps = con.prepareStatement(SQL);
					ps.setInt(1, codConjunto);
					ps.setInt(2, prod.getCodigo());
					ps.setString(3, prod.getTipo());
					ps.execute();
					
					PoolConnection.getPoolConnection().realeaseConnection(con);
					
					
				}
				catch( SQLException e ) 
			      {
						System.out.println("Mensaje Error al ingresar Producto a Conjunto: " + e.getMessage());
						System.out.println("Stack Trace al ingresar Producto a Conjunto: " + e.getStackTrace());
						PoolConnection.getPoolConnection().realeaseConnection(con);
			      }
		
	}
	
	/* DEVUELVE UN CONJUNTO */

	public Conjunto selectConjunto(int codigo) {


		//Obtener conexion BD 
		Connection con = PoolConnection.getPoolConnection().getConnection();
		ResultSet rs = null;
		PreparedStatement ps = null;
		Conjunto conjunto = null;
		
		try{
			
			String SQL = "SELECT * from conjuntos WHERE codigoConjunto ="+codigo;
			
			ps = con.prepareStatement(SQL);
			rs = ps.executeQuery();
			
			while(rs.next()){
				conjunto = new Conjunto(codigo, rs.getString("nombre"), rs.getFloat("descuento"));
				
				PoolConnection.getPoolConnection().realeaseConnection(con);
			}
			
			
		}
		catch( SQLException e ) 
	      {
				System.out.println("Mensaje Error al encontrar Conjunto: " + e.getMessage());
				System.out.println("Stack Trace al encontrar Conjunto: " + e.getStackTrace());
				PoolConnection.getPoolConnection().realeaseConnection(con);
	      }
		return conjunto;
		
	}
	
	/* DESASOCIA UN PRODUCTO DE UN CONJUNTO */

	public void deleteProductoDeConjunto(int codigo, Producto producto) {
		
		//Obtener conexion BD 
		Connection con = PoolConnection.getPoolConnection().getConnection();
		
		PreparedStatement ps = null;
		
		
		try{
			
			String SQL = "DELETE from conjuntosProductos WHERE codigoConjunto = ? AND codigoProducto = ?";
			
			ps = con.prepareStatement(SQL);
			ps.setInt(1, codigo);
			ps.setInt(2, producto.getCodigo());
			
			ps.execute();
			
			PoolConnection.getPoolConnection().realeaseConnection(con);
		}
		catch( SQLException e ) 
	      {
				System.out.println("Mensaje Error al borrar Producto de Conjunto: " + e.getMessage());
				System.out.println("Stack Trace al borrar Producto de Conjunto: " + e.getStackTrace());
				PoolConnection.getPoolConnection().realeaseConnection(con);
	      }
		
	}
	
	/* VERIFICA QUE UN PRODUCTO SE PUEDA BORRAR */

	public boolean sePuedeBorrar(int codProducto) {
		
		//Obtener conexion BD 
		Connection con = PoolConnection.getPoolConnection().getConnection();
		ResultSet rs = null;
		PreparedStatement ps = null;
		boolean bandera = false;
		
		try{
			
			String SQL = "SELECT * from conjuntosProducto WHERE codigoProducto ="+codProducto;
			
			ps = con.prepareStatement(SQL);
			rs = ps.executeQuery();
			
			PoolConnection.getPoolConnection().realeaseConnection(con);
			
			while(rs.next()){
				bandera = true;
				
			}
		}
		catch( SQLException e ) 
	      {
				System.out.println("Mensaje Error al verificar: " + e.getMessage());
				System.out.println("Stack Trace al verificar: " + e.getStackTrace());
				PoolConnection.getPoolConnection().realeaseConnection(con);
	      }
		return bandera;
		
	}
	
	/* ELIMINA UN PRODUCTO */

	public void eliminarProducto(Producto producto) {

		//Obtener conexion BD 
		Connection con = PoolConnection.getPoolConnection().getConnection();
		
		PreparedStatement ps = null;
		
		try{
			
			if(producto.getTipo() == "P"){
			
			String SQL = "DELETE from prendas WHERE codigoPrenda ="+producto.getCodigo();
			
			ps = con.prepareStatement(SQL);
			ps.execute();
			
			PoolConnection.getPoolConnection().realeaseConnection(con);
		}
			if(producto.getTipo() == "C"){
				
			String SQL = "DELETE from conjuntos WHERE codigoConjunto ="+producto.getCodigo();	
			
			ps = con.prepareStatement(SQL);
			ps.execute();
			
			PoolConnection.getPoolConnection().realeaseConnection(con);
		}
		
		
	}
		catch( SQLException e ) 
	      {
				System.out.println("Mensaje Error al borrar Producto: " + e.getMessage());
				System.out.println("Stack Trace al borrar Producto: " + e.getStackTrace());
				PoolConnection.getPoolConnection().realeaseConnection(con);
	      }
	
	}
	
	/* DESCUENTA EL STOCK DE UNA PRENDA */

	public void descontarStockPrenda(Prenda prenda, int cantidad) {

		//Obtener conexion BD 
				Connection con = PoolConnection.getPoolConnection().getConnection();
				
				PreparedStatement ps = null;
				
				try{

					
					String SQL = "UPDATE prendas SET stock = stock - "+cantidad+" WHERE codigoPrenda ="+prenda.getCodigo();
					
					ps = con.prepareStatement(SQL);
					ps.execute();
					PoolConnection.getPoolConnection().realeaseConnection(con);
			
				
				
			}
				catch( SQLException e ) 
			      {
						System.out.println("Mensaje Error al Actualizar stock prenda: " + e.getMessage());
						System.out.println("Stack Trace al actualizar sotck prenda: " + e.getStackTrace());
						PoolConnection.getPoolConnection().realeaseConnection(con);
			      }
		
	}
	
	/* UPDATE PRENDA SIN TEMPORADA */

	public void updateSinTemporada(int codigo, String nombre, int stock) {
		//Obtener conexion BD 
		Connection con = PoolConnection.getPoolConnection().getConnection();
		
		PreparedStatement ps = null;
		
		try{
			
			String SQL = "UPDATE prendas SET nombre = "+nombre+", stock = "+stock+ " WHERE codigoPrenda ="+codigo;
			
			ps = con.prepareStatement(SQL);
			ps.execute();
			PoolConnection.getPoolConnection().realeaseConnection(con);
		}
		
		catch( SQLException e ) 
	      {
				System.out.println("Mensaje Error al Actualizar prenda: " + e.getMessage());
				System.out.println("Stack Trace al actualizar prenda: " + e.getStackTrace());
				PoolConnection.getPoolConnection().realeaseConnection(con);
	      }
		
	}
	
	/* UPDATE PRENDA CON TEMPORADA */

	public void updateConTemporada(int codigo, String nombre, int stock, String estacion) {
		
		//Obtener conexion BD 
				Connection con = PoolConnection.getPoolConnection().getConnection();
				
				PreparedStatement ps = null;
				
				try{
					
					String SQL = "UPDATE prendas SET nombre = "+nombre+", stock = "+stock+ ", estacion = "+estacion+ "  WHERE codigoPrenda ="+codigo;
					
					ps = con.prepareStatement(SQL);
					ps.execute();
					PoolConnection.getPoolConnection().realeaseConnection(con);
				}
				
				catch( SQLException e ) 
			      {
						System.out.println("Mensaje Error al Actualizar prenda: " + e.getMessage());
						System.out.println("Stack Trace al actualizar prenda: " + e.getStackTrace());
						PoolConnection.getPoolConnection().realeaseConnection(con);
			      }
		
		
	}
	
	/* UPDATE CONJUNTO */

	public void updateConjunto(int codigo, String nombre, float descuento) {

		//Obtener conexion BD 
		Connection con = PoolConnection.getPoolConnection().getConnection();
		
		PreparedStatement ps = null;
		
		try{
			String SQL = "UPDATE conjuntos SET nombre = "+nombre+", descuento = "+descuento+ " WHERE codigoPrenda ="+codigo;
			
			ps = con.prepareStatement(SQL);
			ps.execute();
			PoolConnection.getPoolConnection().realeaseConnection(con);
			
		}
		catch( SQLException e ) 
	      {
				System.out.println("Mensaje Error al Actualizar conjunto: " + e.getMessage());
				System.out.println("Stack Trace al actualizar conjunto: " + e.getStackTrace());
				PoolConnection.getPoolConnection().realeaseConnection(con);
	      }
		
	}
	
	/* UPDATE STOCK */

	public void updateStock(int codigo, float stock) {

		//Obtener conexion BD 
				Connection con = PoolConnection.getPoolConnection().getConnection();
				
				PreparedStatement ps = null;
				
				try{
					String SQL = "UPDATE prendas SET stock = "+stock+" WHERE codigoPrenda ="+codigo;
					
					ps = con.prepareStatement(SQL);
					ps.execute();
					PoolConnection.getPoolConnection().realeaseConnection(con);
					
				}
				
				catch( SQLException e ) 
			      {
						System.out.println("Mensaje Error al Agregar Stock: " + e.getMessage());
						System.out.println("Stack Trace al Agregar Stock: " + e.getStackTrace());
						PoolConnection.getPoolConnection().realeaseConnection(con);
			      }
		
	}




}